package pers.bc.utils.pub;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Stack;
import java.util.concurrent.ConcurrentHashMap;

import pers.bc.utils.Bean.BeanHelper;
import pers.bc.utils.Bean.BeanUtil;
import pers.bc.utils.Bean.ReflectionUtil;
import pers.bc.utils.constant.IPubCons;

/**
 * 集合对象的一些助手工具类
 * 
 * @version 1.0<br>
 * @qualiFild nc.pub.itf.tools.pub.CollectionUtil.java<br>
 * @author：licheng<br>
 * @date Created on 2019-8-12<br>
 */
public final class CollectionUtil implements IPubCons
{
    
    /*************************************************************
     * <br>
     * *说明： java list分割 每一千一个list Stream的方式 <br>
     * &#064;see <br>
     * &#064;params null <br>
     * &#064;return <br>
     * &#064;author libencheng <br>
     * &#064;date Created on 2024/12/13 <br>
     * &#064;time 17:29 <br>
     * &#064;version 1.0 <br>
     ************************************************************* <br>
     */
    // public static List<List<?> > splitListStream(List<?> list, int chunkSize)
    // {
    //
    // return IntStream.range(0,(list.size() + chunkSize - 1) / chunkSize)
    // .mapToObj(i -> list.subList(i * chunkSize, Math.min((i + 1) * chunkSize,
    // list.size())))
    // .collect(Collectors.toList());
    // }
    
    /*************************************************************
     * <br>
     * *说明： java list分割 每一千一个list<br>
     * &#064;see <br>
     * &#064;params null <br>
     * &#064;return <br>
     * &#064;author libencheng <br>
     * &#064;date Created on 2024/12/13 <br>
     * &#064;time 17:29 <br>
     * &#064;version 1.0 <br>
     ************************************************************* <br>
     */
    public static List<List<?>> splitList(final List<?> list, final int chunkSize)
    {
        
        return new ArrayList<List<?>>()
        {
            private static final long serialVersionUID = 1L;
            {
                for (int i = 0; i < PubEnvUtil.getSize(list); i += chunkSize)
                {
                    add(list.subList(i, Math.min(i + chunkSize, list.size())));
                }
            }
        };
    }
    
    @SafeVarargs
    // 表示此方法可以接收可变参数
    public static <T> ArrayList<T> toArrayList(T... values)
    { // 定义一个泛型方法，将可变参数转换为ArrayList
        return (ArrayList<T>) tolist(false, values); // 调用tolist方法，生成ArrayList并返回
    }
    
    @SafeVarargs
    // 表示此方法可以接收可变参数
    public static <T> LinkedList<T> toLinkList(T... values)
    { // 定义一个泛型方法，将可变参数转换为LinkedList
        return (LinkedList<T>) tolist(true, values); // 调用tolist方法，生成LinkedList并返回
    }
    
    public static <T> List<T> tolist(boolean isLinked, Collection<T> collection)
    { // 定义一个方法将Collection转换为List，带有是否为LinkedList的参数
        if (null == collection) return list(isLinked); // 如果集合为空，返回一个空的List
        return isLinked ? new LinkedList<>(collection) : new ArrayList<>(collection); // 根据isLinked返回相应类型的List
    }
    
    public static <T> List<T> tolist(boolean isLinked, T... values)
    { // 定义一个方法将可变参数转换为List，带有是否为LinkedList的参数
        if (values == null || values.length == 0) return list(isLinked); // 如果可变参数为空或长度为0，返回空的List
        
        final List<T> arrayList = (List<T>) (isLinked ? new LinkedList<>() : new ArrayList<>(values.length)); // 根据isLinked创建相应的List
        Collections.addAll(arrayList, values); // 将可变参数添加到List中
        
        return arrayList; // 返回生成的List
    }
    
    public static <T> List<T> list(boolean isLinked)
    { // 定义一个方法，返回空的List
        return (List<T>) (isLinked ? new LinkedList<T>() : new ArrayList<T>()); // 根据isLinked返回相应类型的空List
    }
    
    public static <K, V> HashMap<K, V> newHashMap()
    { // 定义一个方法，创建一个新的HashMap
        return new HashMap(); // 返回新的HashMap实例
    }
    
    public static <K, V> ConcurrentHashMap<K, V> newConcurrentHashMap()
    { // 定义一个方法，创建一个新的ConcurrentHashMap
        return newConcurrentHashMap(16); // 默认初始化容量为16
    }
    
    public static <K, V> ConcurrentHashMap<K, V> newConcurrentHashMap(int size)
    { // 定义一个方法，创建一个新的ConcurrentHashMap，指定初始容量
        int initCapacity = size <= 0 ? 16 : size; // 如果size小于等于0，默认容量为16
        return new ConcurrentHashMap(initCapacity); // 返回新的ConcurrentHashMap实例
    }
    
    public static void putAtomRefer(Map<String, Object> target, String key, Object value)
    { // 定义一个静态方法，将值放入目标Map中
        if (PubEnvUtil.isEmptyObj(target) || PubEnvUtil.isEmptyObj(key) || PubEnvUtil.isEmptyObj(value)) return; // 检查目标Map、键和值是否为空，如果任意一个为空则返回
        
        Object obj = target.get(key); // 从目标Map中获取指定键的值
        if (PubEnvUtil.isEmptyObj(obj)) // 如果获取的值为空
            obj = value; // 将值设置为输入的value
        else if (PubEnvUtil.isNotEmptyObj(obj))
        { // 如果获取的值不为空
            if (obj instanceof Collection && value instanceof Collection)
            { // 如果值和输入的值都是集合类型
                ((Collection) obj).addAll((Collection) value); // 将输入的集合添加到现有集合中
            }
            if (obj instanceof Integer && value instanceof Integer)
            { // 如果值和输入的值都是整数类型
                obj = ((Integer) obj) + ((Integer) value); // 将输入的整数与已有整数相加
            }
            if (obj instanceof String && value instanceof String)
            { // 如果值和输入的值都是字符串类型
                obj = ((String) obj) + ((String) value); // 将输入的字符串与已有字符串连接
            }
        }
        
        target.put(key, obj); // 将最终的值放入目标Map中，使用指定的键
    }
    
    public static Object[][] toObjectArray(Map<?, ?> map)
    { // 定义一个方法，将Map转换为二维Object数组
        if (map == null)
        { // 如果Map为空
            return (Object[][]) null; // 返回null
        }
        else
        { // 如果Map不为空
            Object[][] result = new Object[map.size()][2]; // 创建一个二维数组，行数为Map的大小，列数为2
            if (map.isEmpty())
            { // 如果Map为空
                return result; // 返回空的二维数组
            }
            else
            { // 如果Map不为空
                int index = 0; // 初始化索引
                
                for (Iterator arg2 = map.entrySet().iterator(); arg2.hasNext(); ++index)
                { // 遍历Map的每个条目
                    Entry entry = (Entry) arg2.next(); // 获取当前条目
                    result[index][0] = entry.getKey(); // 将条目的键放入二维数组的第一列
                    result[index][1] = entry.getValue(); // 将条目的值放入二维数组的第二列
                }
                
                return result; // 返回生成的二维数组
            }
        }
    }
    
    /*************************************************************
     * <br>
     * 
     * 说明: Collection 反转<br>
     * 
     * @Description <br>
     * @Date Created on 2022/8/18 16:25 <br>
     * @param c <br>
     * @return java.util.Collection <br>
     * @Author LIBENCHENG
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public static Collection reverse(Collection c)
    {
        if (PubEnvUtil.isEmptyObj(c))
        {
            return null;
        }
        Collection temp = ReflectionUtil.newInstance(c.getClass());
        Stack stack = new Stack();
        for (Object obj : c)
        {
            stack.push(obj);
        }
        while (!stack.isEmpty())
        {
            temp.add(stack.pop());
        }
        
        return temp;
    }
    
    public static Map<String, Object> receiveGroupMap(List<Map<String, Object>> dataList, Object key)
    {
        return receiveGroupMap(dataList, key, null);
    }
    
    public static Map<String, List> receiveGroupListMap(List<Map<String, Object>> dataList, Object key)
    {
        return receiveGroupListMap(dataList, key, null);
    }
    
    /*************************************************************
     * <br>
     * 
     * 说明: 分组得到想要的数�? <br>
     * 
     * @Description <br>
     * @Date Created on 2022/6/13 12:41 <br>
     * @param dataList
     * @return java.util.Map<String, Map < String, String>> <br>
     * @Author LIBENCHENG
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public static Map<String, Object> receiveGroupMap(final List<Map<String, Object>> dataList, final Object key, final Class zlass)
    { // 定义一个静态方法，接收一个列表和键及类类型，返回一个Map
        return new ConcurrentHashMap<String, Object>()
        { // 创建一个线程安全的HashMap
            { // 初始化块
                for (Object temp : dataList)
                { // 遍历传入的dataList中的每个元素
                    if (PubEnvUtil.isNotEmptyObj(zlass))
                    { // 如果zlass不为空
                        temp = BeanUtil.parseVO(temp, zlass); // 将temp对象转换为zlass类型的对象
                        put(StringUtil.valueOfZero(BeanHelper.getProperty(temp, StringUtil.valueOf(key))), temp); // 获取temp对象中指定属性的值，并将其作为键，将temp对象作为值存入Map
                    }
                    else if (temp instanceof Map)
                    { // 如果temp是Map类型
                      // logger.info("receiveGroupMap-->");
                      // // 可选：记录日志，表明进入该分支
                      // logger.info("{}",
                      // temp); //
                      // 可选：记录temp的内容
                        put(StringUtil.valueOfZero(((Map) temp).get(StringUtil.toString(key))), temp); // 从temp中获取key对应的值，并将其作为键，将temp作为值存入Map
                    }
                    else
                    { // 如果temp既不是zlass类型也不是Map类型
                        throw new RuntimeException("没有得到分组信息?"); // 抛出运行时异常，提示分组信息未得到
                    }
                }
            } // 初始化块结束
        }; // 返回初始化完成的ConcurrentHashMap
    }
    
    /*************************************************************
     * <br>
     * 
     * 说明: 分组得到想要的数�?<br>
     * 
     * @Description <br>
     * @Date Created on 2022/6/16 18:02 <br>
     * @param dataList
     * @param key 以谁分组<br>
     * @return java.util.Map<java.lang.String, java.util.List < java.util.Map < java.lang.String,
     *         java.lang.String>>> <br>
     * @Author LIBENCHENG
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public static Map<String, List> receiveGroupListMap(final List<Map<String, Object>> dataList, final Object key, final Class zlass)
    {
        return new ConcurrentHashMap<String, List>()
        {
            {
                for (Map temp : dataList)
                {
                    Object obj = temp;
                    if (PubEnvUtil.isNotEmptyObj(zlass))
                    {
                        obj = BeanUtil.parseVO(temp, zlass);
                    }
                    Object keyStr = temp.get(StringUtil.toString(key));
                    if (PubEnvUtil.isNotEmptyObj(keyStr) && keyStr instanceof Long) keyStr = StringUtil.valueOfEmpty(keyStr);
                    
                    List<Object> tempList = get(keyStr);
                    if (PubEnvUtil.getSize(tempList) < 1)
                    {
                        tempList = new LinkedList<Object>();
                    }
                    tempList.add(obj);
                    put(StringUtil.valueOfZero(keyStr), tempList);
                }
            }
        };
        
    }
    
    /*************************************************************
     * <br>
     * 
     * 说明: 对象深度克隆<br>
     * 
     * @Description <br>
     * @Date Created on 2022/5/10 16:13 <br>
     * @param obj <br>
     * @return java.lang.Object <br>
     * @Author LIBENCHENG
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public static Object cloneObj(Object obj)
    {
        try
        {
            
            if (obj instanceof Map)
            {
                final Map temMap = (Map) obj;
                final HashMap<Object, Object> map = new HashMap();
                Iterator<Entry<Object, Object>> entries = map.entrySet().iterator();
                while (entries.hasNext())
                {
                    Entry<Object, Object> entry = entries.next();
                    map.put(entry.getKey(), entry.getValue());
                }
                
                return map;
            }
            // if (obj instanceof List)
            // {
            //
            // List tempList = (List) obj;
            // List idcards = tempList.stream().map(Object ::
            // Obj).collect(Collectors.toList());
            //
            // }
        }
        catch (Exception e)
        {
            return null;
        }
        
        return deepCloneObj(obj);
    }
    
    /*************************************************************
     * <br>
     * 
     * 说明: 对象深度克隆<br>
     * 
     * @Description <br>
     * @Date Created on 2022/5/10 16:13 <br>
     * @param obj <br>
     * @return java.lang.Object <br>
     * @Author LIBENCHENG
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public static Object deepCloneObj(Object obj)
    {
        // 定义一个静态方法，接收一个对象并返回其深拷贝
        try
        { // 开始尝试块，处理可能发生的异常
          // 将对象写到流中
            ByteArrayOutputStream bo = new ByteArrayOutputStream(); // 创建字节数组输出流，用于存放对象的字节
            ObjectOutputStream oo = new ObjectOutputStream(bo); // 创建对象输出流，将对象写入字节数组输出流
            // 从流里读出来
            oo.writeObject(obj); // 将输入的对象写入对象输出流
            ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray()); // 创建字节数组输入流，从字节数组中获取数据
            ObjectInputStream oi = new ObjectInputStream(bi); // 创建对象输入流，用于从字节数组输入流读取对象
            return (oi.readObject()); // 从对象输入流中读取对象并返回该对象
        }
        catch (Exception e)
        { // 捕获可能抛出的异常
            System.err.println(StringUtil.toString(e)); // 将异常信息打印到标准错误输出流
            return new Object(); // 返回一个新的空对象作为默认值
        }
    }
    
    public static String transObj2Josn(Object obj) throws Exception
    {
        // 定义一个将对象转换为JSON字符串的方法，可能会抛出异常
        if (obj instanceof Map)
        { // 如果对象是Map类型
            return map2Josn((Map) obj); // 调用map2Josn方法将Map转换为JSON字符串并返回
        }
        else if (obj instanceof Collection)
        { // 如果对象是Collection类型
            return map2Josn((Collection) obj); // 调用map2Josn方法将Collection转换为JSON字符串并返回
        }
        else if (BeanHelper.isBeanClass(obj.getClass()))
        { // 如果对象是Bean类
            return map2Josn(transBean2Map(obj, Boolean.TRUE)); // 将Bean转换为Map后，再转换为JSON字符串并返回
        }
        else
        { // 如果对象不符合以上类型
            throw new IllegalArgumentException("不支持转换成json，请检查确认！"); // 抛出非法参数异常，提示不支持转换
        }
    }
    
    /**
     * *********************************************************** <br>
     * 说明：mapList转json 内部类，建议使用这个方法<br>
     * 
     * @param mapList
     * @return <br>
     * @throws Exception
     * @String <br>
     * @methods pers.bc.utils.pub.CollectionUtil#map2JosnStr <br>
     * @author LiBencheng <br>
     * @date Created on 2020-6-30 <br>
     * @time 上午9:00:06 <br>
     * @version 1.0 <br>
     *          ************************************************************ <br>
     * @see <br>
     */
    public static String map2Josn(Collection<?> mapList) throws Exception
    { // 定义一个方法，将Collection转换为JSON字符串，可能会抛出异常
        if (PubEnvUtil.getSize(mapList) < 1)
        { // 如果Collection的大小小于1
            return EMPTY; // 返回空字符串
        }
        StringBuffer strb = new StringBuffer(LEFT_SQ_BRACKET); // 创建一个StringBuffer，并添加左方括号
        for (Object obj : mapList)
        { // 遍历Collection中的每个对象
            if (PubEnvUtil.isEmptyObj(obj))
            { // 如果对象为空
                strb.append(obj).append(COMMA).append(CRLF); // 追加null值和逗号换行符
            }
            else
            { // 如果对象不为空
              // obj = CollectionUtil.transBean2Map(obj); //
              // 可选：将对象转换为Map
                if (obj instanceof Map)
                { // 如果对象是Map类型
                    strb.append(map2Josn((Map<?, ?>) obj)).append(COMMA).append(CRLF); // 递归调用map2Josn，将Map转换为JSON字符串并追加
                }
                else if (BeanHelper.isBeanClass(obj.getClass()))
                { // 如果对象是Bean类型
                    strb.append(map2Josn(transBean2Map(obj))).append(COMMA).append(CRLF); // 将Bean转换为Map后，再转换为JSON字符串并追加
                }
                else if (obj instanceof String)
                { // 如果对象是字符串
                    strb.append(QUOTE).append(obj).append(QUOTE).append(COMMA).append(CRLF); // 为字符串添加引号并追加逗号换行符
                }
                else
                { // 如果对象是其他类型
                    strb.append(obj).append(COMMA).append(CRLF); // 直接追加对象值和逗号换行符
                }
            }
        }
        
        return deleteStr(strb, 3).append(RIGHT_SQ_BRACKET).toString().replace("\r\n", "").replace("\n", ""); // 删除最后的逗号，添加右方括号，并返回最终的JSON字符串
    }
    
    /**
     * *********************************************************** <br>
     * 说明�? map转json,内部类，建议使用这个方法<br>
     * 
     * @param map
     * @return <br>
     * @throws Exception
     * @String <br>
     * @methods pers.bc.utils.pub.CollectionUtil#map2JosnStr <br>
     * @author LiBencheng <br>
     * @date Created on 2020-6-30 <br>
     * @time 上午8:59:56 <br>
     * @version 1.0 <br>
     *          ************************************************************ <br>
     * @see <br>
     */
    public static String map2Josn(Map<?, ?> map) throws Exception
    { // 定义一个方法，将Map转换为JSON字符串，可能会抛出异常
        if (PubEnvUtil.getSize(map) < 1)
        { // 如果Map的大小小于1
            return EMPTY; // 返回空字符串
        }
        StringBuffer sb = new StringBuffer(LEFT_BRACE); // 创建一个StringBuffer，并添加左大括号
        for (Object key : map.keySet())
        { // 遍历Map的所有键
            Object obj = map.get(key); // 根据键获取对应的值
            if (PubEnvUtil.isEmptyObj(obj))
            { // 如果值为空
                appendSubStr(sb, key, obj, Boolean.TRUE); // 追加键值对，值为null时添加引号
            }
            else
            { // 如果值不为空
                if (obj instanceof Map)
                { // 如果值是Map类型
                    appendSubStr(sb, key, map2Josn((Map<?, ?>) obj), Boolean.FALSE); // 递归调用map2Josn，将Map转换为JSON字符串，追加到StringBuffer
                }
                else if (obj instanceof List)
                { // 如果值是List类型
                    appendSubStr(sb, key, map2Josn((List<?>) obj), Boolean.FALSE); // 递归调用map2Josn，将List转换为JSON字符串，追加到StringBuffer
                }
                else if (BeanHelper.isBeanClass(obj.getClass()))
                { // 如果值是Bean类型
                    appendSubStr(sb, key, map2Josn(transBean2Map(obj)), Boolean.FALSE); // 将Bean转换为Map后，再转换为JSON字符串，追加到StringBuffer
                }
                // else if (String.valueOf(obj).contains(LEFT_BRACE) ||
                // String.valueOf(obj).contains(LEFT_SQ_BRACKET))
                // {
                // appendSubStr(sb, key, obj, Boolean.FALSE);
                // }
                else
                { // 如果值是其他类型
                    appendSubStr(sb, key, obj, Boolean.TRUE); // 追加键值对，值为其他类型时添加引号
                }
            }
        }
        
        return deleteStr(sb, 3).append(RIGHT_BRACE).toString().replace("\r\n", "").replace("\n", ""); // 删除最后的逗号，添加右大括号，并返回最终的JSON字符串
    }
    
    public static Map<String, Object> transBean2Map(Object obj) throws Exception
    { // 定义一个方法，将Java Bean转换为Map，可能会抛出异常
        return transBean2Map(obj, Boolean.FALSE); // 调用内部方法transBean2Map，将isBeanClass参数设置为false
    }
    
    public static Map<String, Object> transBean2Map(Object obj, Boolean isBeanClass) throws Exception
    {
        // 定义一个方法，将Java
        // Bean转换为Map，可能会抛出异常3
        if (null == obj) return null; // 如果对象为空，返回null
        Map<String, Object> map = new LinkedHashMap<String, Object>(); // 创建一个有序的Map，用于存储属性名与属性值
        BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass()); // 获取对象的Bean信息
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); // 获取属性描述符数组
        if (null != propertyDescriptors && propertyDescriptors.length > 0)
        { // 如果属性描述符数组不为空
            for (PropertyDescriptor property : propertyDescriptors)
            { // 遍历每个属性描述符
                String key = property.getName(); // 获取属性名
                if (null != key && !(key.equals("class") || key.equals("Class")))
                { // 如果属性名不为空且不为"class"
                    Method getter = property.getReadMethod(); // 获取属性的getter方法
                    if (null != getter)
                    { // 如果getter方法不为空
                        Object value = getter.invoke(obj); // 调用getter方法获取属性值
                        try
                        {
                            if (PubEnvUtil.isNotNullObj(value) && isBeanClass && BeanHelper.isBeanClass(value.getClass())) // 如果值不为空且是Bean类型
                                value = transBean2Map(value, isBeanClass); // 递归调用将Bean转换为Map
                            if (PubEnvUtil.isNotNullObj(value) && value.getClass().isArray())
                            { // 如果值是数组
                                if (value instanceof Object[])
                                { // 如果值是Object数组
                                    if (PubEnvUtil.getSize((Object[]) value) < 1) value = ""; // 如果数组大小小于1，设置为空字符串
                                    else
                                    {
                                        Boolean isStr = Boolean.FALSE; // 初始化是否是字符串的标记
                                        List temp = new ArrayList(); // 创建一个临时List用于存储处理后的值
                                        for (Object obj2 : (Object[]) value)
                                        { // 遍历数组中的每个元素
                                            if (PubEnvUtil.isNotNullObj(obj2) && BeanHelper.isBeanClass(obj2.getClass())) // 如果元素是Bean类型
                                                temp.add(transBean2Map(obj2, isBeanClass)); // 将Bean转换为Map并添加到临时List
                                            else if (obj2 instanceof String)
                                            { // 如果元素是字符串
                                                isStr = Boolean.TRUE; // 设置标记为真
                                                break; // 结束循环
                                            }
                                            else
                                                temp.add(StringUtil.toString(obj2)); // 将元素转换为字符串并添加到临时List
                                        }
                                        if (isStr) value = StringUtil.toString((Object[]) value, Boolean.FALSE); // 如果是字符串，转换整个数组为字符串
                                        if (!isStr && PubEnvUtil.getSize((Object[]) value) > 0) value = temp; // 如果不是字符串且数组不为空，设置值为临时List
                                    }
                                }
                                else
                                    value = StringUtil.toString(value); // 如果值不是Object数组，转换为字符串
                            }
                            if (PubEnvUtil.isNotNullObj(value) // 如果值不为空且不是Boolean、集合、Map或数组
                                && !(value instanceof Boolean || value instanceof Collection || value instanceof Map
                                    || value.getClass().isArray()))
                                value = StringUtil.toString(value); // 将值转换为字符串
                            
                            map.put(key, value); // 将键值对放入Map中
                        }
                        catch (Exception e)
                        { // 捕获异常
                            JudgeAssertUtil.throwException(e, "MyLogs",
                                "pers.bc.utils.pub.CollectionUtil.transBean2Map()异常：" + key + "/" + value); // 抛出自定义异常
                        }
                    }
                }
            }
        }
        
        return map; // 返回构建好的Map
    }
    
    /*************************************************************
     * <br>
     * *说明：定义一个方法，用于从StringBuffer中删除指定长度的字符串 <br>
     * &#064;see <br>
     * &#064;params null <br>
     * &#064;return <br>
     * &#064;author libencheng <br>
     * &#064;date Created on 2024/11/27 <br>
     * &#064;time 14:24 <br>
     * &#064;version 1.0 <br>
     ************************************************************* <br>
     */
    public static StringBuffer deleteStr(StringBuffer sbStr, int i)
    {
        // 从StringBuffer的末尾开始，删除长度为i的字符串，并返回修改后的StringBuffer
        return sbStr.delete(sbStr.length() - i, sbStr.length());
    }
    
    public static void appendSubStr(StringBuffer sbStr, Object key, Object objValue, Boolean isAddQuote)
    {
        if (isAddQuote)
        { // 如果需要添加引号
            if (objValue instanceof List) // 如果objValue是List类型
                sbStr.append(QUOTE) // 添加引号
                    .append(key) // 添加键
                    .append(QUOTE) // 添加结束引号
                    .append(COLON) // 添加冒号
                    .append(LEFT_SQ_BRACKET) // 添加左方括号
                    .append(RIGHT_SQ_BRACKET) // 添加右方括号
                    .append(COMMA) // 添加逗号
                    .append(CRLF); // 添加换行符
            else
                // 如果objValue不是List类型
                sbStr.append(QUOTE) // 添加引号
                    .append(key) // 添加键
                    .append(QUOTE) // 添加结束引号
                    .append(COLON) // 添加冒号
                    .append(QUOTE) // 添加引号
                    .append(StringUtil.valueOfEmpty(objValue)) // 将objValue转换为字符串并添加
                    .append(QUOTE) // 添加结束引号
                    .append(COMMA) // 添加逗号
                    .append(CRLF); // 添加换行符
        }
        else
        { // 如果不需要添加引号
            sbStr.append(QUOTE) // 添加引号
                .append(key) // 添加键
                .append(QUOTE) // 添加结束引号
                .append(COLON) // 添加冒号
                .append(StringUtil.valueOfEmpty(objValue)) // 将objValue转换为字符串并添加
                .append(COMMA) // 添加逗号
                .append(CRLF); // 添加换行符
        }
    }
}
